package org.csu.softwaremetrics_demo.entity.common;

import java.util.HashMap;
import java.util.Map;

/**
 * @Description: LKMetricSingleClass类用于存储单个类的LK度量指标。
 * @Author: Jukomu
 * @Package: org.csu.softwaremetrics_demo.entity.common
 * @Project: SoftwareMetrics_demo
 * @name: LKMetricSingleClass
 * @Date: 2025/4/6-20:14
 * @Filename: LKMetricSingleClass
 */
public class LKMetricSingleClass {
    // 文件路径
    private String file;
    // 类名
    private String className;
    // 类型
    private String type;

    // 类中的字段数量
    private int nof;
    // 类中的方法数量
    private int nom;
    // 类中的操作数量
    private int noo;
    // 类中的属性数量
    private int noa;
    // 类的复杂度
    private double si;
    // 类的继承深度
    private int dit;

    // 特定指标的映射
    private final Map<String, Integer> specific;
    // 是否有错误
    private boolean error;

    // 构造函数，初始化文件路径、类名和类型
    public LKMetricSingleClass(String file, String className, String type) {
        this.file = file;
        this.className = className;
        this.type = type;

        this.specific = new HashMap<>();
    }

    // 将对象转换为Map
    public Map<String, Object> toMap() {
        Map<String, Object> map = new HashMap<>();
        // 分割文件路径，获取文件名
        String[] pathList = file.split("\\\\");
        map.put("file", pathList[pathList.length - 1]);
        map.put("class", className);
        map.put("type", type);
        map.put("nof", nof);
        map.put("nom", nom);
        map.put("noo", noo);
        map.put("noa", noa);
        map.put("si", si);
        map.put("dit", dit);
        map.put("specific", specific);
        map.put("error", error);

        return map;
    }

    // 重写hashCode方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        // 计算文件路径的hashCode
        result = prime * result + ((file == null) ? 0 : file.hashCode());
        return result;
    }

    // 重写equals方法
    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        LKMetricSingleClass other = (LKMetricSingleClass) obj;
        // 比较文件路径是否相等
        if (file == null) {
            return other.file == null;
        } else {
            return file.equals(other.file);
        }
    }

    // 重写toString方法
    @Override
    public String toString() {
        return "LKMetricSingleClass [file=" + file + ", className=" + className + ", type="
                + type + ", nof=" + nof + ", nom=" + nom + ", noo=" + noo + ", noa=" + noa + ", si="
                + si + ", dit=" + dit + " , specific=" + specific + ", error=" + error + "]";
    }

    // 获取文件路径
    public String getFile() {
        return file;
    }

    // 设置文件路径
    public void setFile(String file) {
        this.file = file;
    }

    // 获取类名
    public String getClassName() {
        return className;
    }

    // 设置类名
    public void setClassName(String className) {
        this.className = className;
    }

    // 获取类型
    public String getType() {
        return type;
    }

    // 设置类型
    public void setType(String type) {
        this.type = type;
    }

    // 获取类中的字段数量
    public int getNof() {
        return nof;
    }

    // 设置类中的字段数量
    public void setNof(int nof) {
        this.nof = nof;
    }

    // 获取类中的方法数量
    public int getNom() {
        return nom;
    }

    // 设置类中的方法数量
    public void setNom(int nom) {
        this.nom = nom;
    }

    // 获取类中的操作数量
    public int getNoo() {
        return noo;
    }

    // 设置类中的操作数量
    public void setNoo(int noo) {
        this.noo = noo;
    }

    // 获取类中的属性数量
    public int getNoa() {
        return noa;
    }

    // 设置类中的属性数量
    public void setNoa(int noa) {
        this.noa = noa;
    }

    // 获取类的复杂度
    public double getSi() {
        return si;
    }

    // 设置类的复杂度
    public void setSi(double si) {
        this.si = si;
    }

    // 获取特定指标的映射
    public Map<String, Integer> getSpecific() {
        return specific;
    }

    // 获取是否有错误
    public boolean isError() {
        return error;
    }

    // 设置错误状态
    public void error() {
        this.error = true;
    }

    // 获取特定指标的值
    public int getSpecific(String key) {
        if (!specific.containsKey(key)) return -1;
        return specific.get(key);
    }

    // 添加特定指标的值
    public void addSpecific(String key, int value) {
        specific.put(key, value);
    }

    // 获取类的继承深度
    public int getDit() {
        return dit;
    }

    // 设置类的继承深度
    public void setDit(int dit) {
        this.dit = dit;
    }

    // 设置错误状态
    public void setError(boolean error) {
        this.error = error;
    }
}
